package com.yklx.youke.admin.controller;

import com.yklx.youke.dto.MenuDto;
import com.yklx.youke.entity.Menu;
import com.yklx.youke.admin.mapper.MenuMapper;
import com.yklx.util.JwtUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.stream.Collectors;

@RestController
@RequestMapping("/api/admin")
@CrossOrigin(origins = "*", maxAge = 3600)
public class MenuController {

    @Autowired
    private JwtUtil jwtUtil;

    @Autowired
    private MenuMapper menuMapper;

    /**
     * 根据用户角色获取菜单列表
     * 此端点将根据用户角色返回相应的菜单
     */
    @GetMapping("/menus/user")
    public ResponseEntity<List<MenuDto>> getUserMenus(@RequestHeader(value = "Authorization", required = false) String token) {
        try {
            String userId = null;
            String userRole = "USER"; // 默认角色
            
            // 提取用户ID和角色
            if (token != null && token.startsWith("Bearer ")) {
                userId = extractUserIdFromToken(token);
                if (userId != null) {
                    System.out.println("Valid token for user: " + userId);
                    userRole = getUserRole(userId);
                    System.out.println("User role: " + userRole);
                } else {
                    System.out.println("Invalid token provided");
                }
            } else {
                System.out.println("No authorization token provided or invalid format");
            }

            // 从数据库获取所有菜单
            List<Menu> allMenus = menuMapper.getAllMenus();
            System.out.println("Total menus retrieved from DB: " + allMenus.size());

            // 根据用户角色过滤菜单 - 先获取过滤后的菜单列表
            List<Menu> filteredMenus;
            if ("ADMIN".equalsIgnoreCase(userRole)) {
                // 管理员可以看到大部分菜单
                filteredMenus = allMenus.stream()
                        .filter(menu -> isVisibleForAdmin(menu))
                        .collect(Collectors.toList());
            } else if ("TEACHER".equalsIgnoreCase(userRole)) {
                // 教师只能看到与教学相关的菜单
                filteredMenus = allMenus.stream()
                        .filter(menu -> isVisibleForTeacher(menu))
                        .collect(Collectors.toList());
            } else if ("PARENT".equalsIgnoreCase(userRole)) {
                // 家长只能看到与孩子管理、预约相关的菜单
                filteredMenus = allMenus.stream()
                        .filter(menu -> isVisibleForParent(menu))
                        .collect(Collectors.toList());
            } else if ("ASSISTANT".equalsIgnoreCase(userRole)) {
                // 助教只能看到与教师管理相关的菜单
                filteredMenus = allMenus.stream()
                        .filter(menu -> isVisibleForAssistant(menu))
                        .collect(Collectors.toList());
            } else {
                // 其他用户返回基本菜单
                filteredMenus = allMenus.stream()
                        .filter(menu -> isVisibleForGeneralUser(menu))
                        .collect(Collectors.toList());
            }
            
            System.out.println("Filtered menus for role " + userRole + ": from " + allMenus.size() + " to " + filteredMenus.size());

            // 将Menu实体转换为MenuDto
            List<MenuDto> menuDtos = filteredMenus.stream()
                    .map(this::convertToDto)
                    .collect(Collectors.toList());

            // 构建菜单树结构
            List<MenuDto> menuTree = buildMenuTree(menuDtos);
            System.out.println("Built menu tree with " + menuTree.size() + " root items");

            return ResponseEntity.ok(menuTree);
        } catch (Exception e) {
            e.printStackTrace();
            // 返回空列表而不是错误，确保系统可用性
            return ResponseEntity.ok(new ArrayList<>());
        }
    }

    /**
     * 根据用户角色获取菜单（替代方案）
     */
    @GetMapping("/menus/by-role/{role}")
    public ResponseEntity<List<MenuDto>> getMenusByRole(@PathVariable String role) {
        try {
            // 从数据库获取所有菜单
            List<Menu> allMenus = menuMapper.getAllMenus();
            System.out.println("Total menus retrieved from DB: " + allMenus.size());

            // 过滤特定角色的菜单（在实际应用中，这里应该基于角色权限进行过滤）
            List<Menu> roleSpecificMenus = allMenus.stream()
                    .filter(menu -> isVisibleForRole(menu, role.toUpperCase()))
                    .collect(Collectors.toList());

            // 将Menu实体转换为MenuDto
            List<MenuDto> menuDtos = roleSpecificMenus.stream()
                    .map(this::convertToDto)
                    .collect(Collectors.toList());

            System.out.println("Filtered " + menuDtos.size() + " menus for role: " + role);

            // 构建菜单树结构
            List<MenuDto> menuTree = buildMenuTree(menuDtos);
            System.out.println("Built menu tree with " + menuTree.size() + " root items for role: " + role);

            return ResponseEntity.ok(menuTree);
        } catch (Exception e) {
            e.printStackTrace();
            // 返回空列表而不是错误，确保系统可用性
            return ResponseEntity.ok(new ArrayList<>());
        }
    }

    // 从令牌中提取用户ID
    private String extractUserIdFromToken(String token) {
        if (token != null && token.startsWith("Bearer ")) {
            String actualToken = token.substring(7);
            try {
                return jwtUtil.getUserIdFromToken(actualToken);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
        return null;
    }

    // 根据用户ID获取用户角色
    private String getUserRole(String userId) {
        // 在实际应用中，应该查询数据库获取用户的角色
        // 这里是一个简化实现，实际应该连接UserRoleRepository或UserService
        try {
            // 示例查询逻辑：
            // SELECT role_id FROM user_roles WHERE user_id = userId
            // 或者 SELECT role_id FROM users WHERE user_id = userId
            
            // 临时实现：直接查询用户表的角色
            // 注意：这只是一个示例，实际实现可能需要查询user_roles关联表
            return "ADMIN"; // 临时返回ADMIN，实际中应从数据库查询用户角色
        } catch (Exception e) {
            System.err.println("Error getting user role: " + e.getMessage());
            return "USER"; // 默认角色
        }
    }

    // 检查菜单是否对特定角色可见
    private boolean isVisibleForRole(Menu menu, String role) {
        // 根据菜单ID和用户角色来决定菜单是否可见
        // 这是一个简化的实现，实际应该基于角色权限进行更复杂的检查
        if ("ADMIN".equalsIgnoreCase(role)) {
            // 管理员可以看到大部分菜单，除了特定角色专属的菜单
            return !menu.getMenuId().startsWith("teacher_") && 
                   !menu.getMenuId().startsWith("parent_") && 
                   !menu.getMenuId().startsWith("assistant_");
        } else if ("TEACHER".equalsIgnoreCase(role)) {
            // 教师只能看到与教学相关的菜单
            return menu.getMenuId().startsWith("teacher_") || 
                   menu.getMenuId().contains("course") || 
                   menu.getMenuId().contains("schedule") || 
                   menu.getMenuId().contains("booking") || 
                   menu.getMenuId().contains("teaching");
        } else if ("PARENT".equalsIgnoreCase(role)) {
            // 家长只能看到与孩子管理、预约相关的菜单
            return menu.getMenuId().startsWith("parent_") || 
                   menu.getMenuId().contains("booking") || 
                   menu.getMenuId().contains("children") || 
                   menu.getMenuId().contains("order");
        } else if ("ASSISTANT".equalsIgnoreCase(role)) {
            // 助教只能看到与教师管理相关的菜单
            return menu.getMenuId().startsWith("assistant_") || 
                   menu.getMenuId().contains("teacher");
        } else {
            // 其他用户返回基本菜单
            return menu.getMenuUrl() == null || menu.getMenuUrl().isEmpty() || 
                   menu.getMenuId().contains("profile") || 
                   menu.getMenuId().contains("settings");
        }
    }
    
    // 为不同角色创建菜单可见性检查方法
    private boolean isVisibleForAdmin(Menu menu) {
        // 管理员可以看到大部分菜单，除了特定角色专属的菜单
        if (menu.getMenuId() == null) return false;
        return !menu.getMenuId().startsWith("teacher_") && 
               !menu.getMenuId().startsWith("parent_") && 
               !menu.getMenuId().startsWith("assistant_");
    }

    private boolean isVisibleForTeacher(Menu menu) {
        // 教师只能看到与教学相关的菜单
        if (menu.getMenuId() == null) return false;
        return menu.getMenuId().contains("teacher") || 
               menu.getMenuId().contains("course") || 
               menu.getMenuId().contains("schedule") || 
               menu.getMenuId().contains("booking") || 
               menu.getMenuId().contains("teaching");
    }

    private boolean isVisibleForParent(Menu menu) {
        // 家长只能看到与孩子管理、预约相关的菜单
        if (menu.getMenuId() == null) return false;
        return menu.getMenuId().contains("parent") || 
               menu.getMenuId().contains("booking") || 
               menu.getMenuId().contains("children") || 
               menu.getMenuId().contains("order");
    }

    private boolean isVisibleForAssistant(Menu menu) {
        // 助教只能看到与教师管理相关的菜单
        if (menu.getMenuId() == null) return false;
        return menu.getMenuId().contains("assistant") || 
               menu.getMenuId().contains("teacher");
    }

    private boolean isVisibleForGeneralUser(Menu menu) {
        // 一般用户只显示基本菜单
        if (menu.getMenuId() == null) return false;
        return menu.getMenuId().contains("profile") || 
               menu.getMenuId().contains("settings");
    }
    


    // 构建菜单树
    private List<MenuDto> buildMenuTree(List<MenuDto> allMenus) {
        if (allMenus == null || allMenus.isEmpty()) {
            return new ArrayList<>();
        }

        // 创建映射以快速查找菜单
        Map<String, MenuDto> menuMap = new HashMap<>();
        for (MenuDto menu : allMenus) {
            if (menu.getChildren() == null) {
                menu.setChildren(new ArrayList<>());
            }
            menuMap.put(menu.getMenuId(), menu);
        }

        // 创建根菜单列表
        List<MenuDto> rootMenus = new ArrayList<>();

        // 构建父子关系
        for (MenuDto menu : allMenus) {
            String parentId = menu.getParentId();

            if (parentId == null || parentId.trim().isEmpty() || parentId.equalsIgnoreCase("NULL")) {
                // 这是根菜单
                rootMenus.add(menu);
            } else {
                // 这是子菜单
                MenuDto parent = menuMap.get(parentId);
                if (parent != null && !parent.getMenuId().equals(menu.getMenuId())) {
                    // 确保不是自引用
                    parent.getChildren().add(menu);
                } else {
                    // 如果父菜单不存在，作为根菜单处理
                    rootMenus.add(menu);
                }
            }
        }

        return rootMenus;
    }

    // 将Menu实体转换为MenuDto
    private MenuDto convertToDto(Menu menu) {
        MenuDto dto = new MenuDto();
        dto.setMenuId(menu.getMenuId());
        dto.setMenuName(menu.getMenuName());
        dto.setMenuIcon(menu.getMenuIcon());
        dto.setMenuUrl(menu.getMenuUrl());
        dto.setParentId(menu.getParentId());
        dto.setSortOrder(menu.getSortOrder());
        dto.setIsActive(menu.getIsActive());
        // 处理LocalDateTime字段的序列化问题
        if (menu.getCreatedAt() != null) {
            dto.setCreatedAt(menu.getCreatedAt());
        }
        if (menu.getUpdatedAt() != null) {
            dto.setUpdatedAt(menu.getUpdatedAt());
        }
        // 初始化children列表
        dto.setChildren(new ArrayList<>());
        return dto;
    }
}